#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string>


int main()
{
    int pipefd[2];
    int n = pipe(pipefd);
    if (n < 0) return -1;

    pid_t pid = fork();

    if (pid == 0) // 子进程
    {
        // close(pipefd[1]); // 关闭写端
        close(pipefd[0]);
        
        std::string str = "hello world";
        write(pipefd[1], str.c_str(), str.size());
        printf("I am child, writed a msg: %s\n", str.c_str());

        // char buffer[1024];
        // ssize_t n = read(pipefd[0], buffer, 1024);
        // buffer[n] = 0;
        // printf("child read a msg: %s\n", buffer);

        exit(0);
    }

    // 父进程
    // close(pipefd[0]); // 关闭读端
    close(pipefd[1]);

    char buffer[1024];
    ssize_t len = read(pipefd[0], buffer, 1024);
    buffer[len] = 0;
    printf("I am father, read a msg: %s\n", buffer);
    wait(NULL);

    // std::string msg = "I am father";
    // write(pipefd[1], msg.c_str(), msg.size());
    // printf("father already write msg\n");


    wait(nullptr);

    return 0;
}


// const int item_max = 10;

// const int buffer_size = 5;
// int buffer[buffer_size];
// int count = 0; // 记录缓冲区中任务数量

// int in = 0; // 记录生产者生产位置
// int out = 0; // 记录消费者消费位置

// pthread_mutex_t mutex;
// pthread_cond_t not_full;  // 缓冲区非满，通知生产者生产
// pthread_cond_t not_empty; // 缓冲区非空，通知消费者消费

// void *produce(void *argc)
// {
//     for (int i = 0; i < item_max; i++)
//     {
//         int item = i; // 项目
//         pthread_mutex_lock(&mutex); // 先申请锁

//         while (count == buffer_size) // 缓冲区已满
//         {
//             printf("Producer is waiting: the buffer is full\n");
//             pthread_cond_wait(&not_full, &mutex);
//         }

//         buffer[in++] = item;
//         in %= buffer_size;
//         ++count;
//         printf("Producer produce [%d]-item, count: %d\n", item, count);

//         pthread_cond_signal(&not_empty); // 通知消费者线程消费
//         pthread_mutex_unlock(&mutex);
//         sleep(1);
//     }
//     return nullptr;
// }

// void *consume(void *argc)
// {
//     for (int i = 0; i < item_max; i++)
//     {
//         int item;
//         pthread_mutex_lock(&mutex); // 申请锁

//         while (count == 0) // 缓冲区为空
//         {
//             printf("Consumer is waiting: the buffer is empty\n");
//             pthread_cond_wait(&not_empty, &mutex);
//         }

//         item = buffer[out++];
//         out %= buffer_size;
//         count--;
//         printf("Consumer consume [%d]-item, count: %d\n", item, count);

//         pthread_cond_signal(&not_full); // 通知生产者生产
//         pthread_mutex_unlock(&mutex);
//         sleep(1);
//     }
//     return nullptr;
// }

// int main()
// {
//     pthread_t producer; // 生产者线程
//     pthread_t consumer; // 消费者线程

//     pthread_mutex_init(&mutex, nullptr);
//     pthread_cond_init(&not_full, nullptr);
//     pthread_cond_init(&not_empty, nullptr);

//     pthread_create(&producer, nullptr, produce, nullptr);
//     pthread_create(&consumer, nullptr, consume, nullptr);

//     pthread_join(producer, nullptr);
//     pthread_join(consumer, nullptr);

//     pthread_mutex_destroy(&mutex);
//     pthread_cond_destroy(&not_full);
//     pthread_cond_destroy(&not_empty);
//     return 0;
// }